﻿using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Windows;
using MP3Ganizer.Prism;
using System.Windows.Threading;
using System.IO;

namespace MP3Ganizer
{
    /// <summary>
    /// Interaction logic for App.xaml
    /// </summary>
    public partial class App : Application
    {
        #region Override
        /// <summary>
        /// Point d'entrée de l'application.
        /// </summary>
        /// <param name="e">StartupEventArgs</param>
        protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);
            this.ShutdownMode = ShutdownMode.OnMainWindowClose;
            AppDomain.CurrentDomain.ProcessExit += new EventHandler(CurrentDomain_ProcessExit);
#if !DEBUG
      RunInReleaseMode();
#else
            RunInDebugMode();
#endif
            FlushTemp();
        }

        private void FlushTemp()
        {
            try
            {
                DirectoryInfo d = new DirectoryInfo("./temp");
                FileInfo[] toDelete = d.GetFiles("*.mp3");
                toDelete.ToList<FileInfo>().ForEach(fi => fi.Delete());
            }
            catch
            {

            }
        }

        protected override void OnExit(ExitEventArgs e)
        {
            base.OnExit(e);
            FlushTemp();
        }
        #endregion

        /// <summary>
        /// Lancement du Bootstapper en mode Debug
        /// </summary>
        private void RunInDebugMode()
        {
            PrismBootstrapper bootstrapper = new PrismBootstrapper();
            bootstrapper.Run();
        }

        /// <summary>
        /// Lancement du Bootstapper en mode Releaser (Try/Catch)
        /// </summary>
        private void RunInReleaseMode()
        {
            AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
            App.Current.DispatcherUnhandledException += new DispatcherUnhandledExceptionEventHandler(Current_DispatcherUnhandledException);
            try
            {
                PrismBootstrapper bootstrapper = new PrismBootstrapper();
                bootstrapper.Run();
            }
            catch (Exception ex)
            {
                HandleException(ex);
            }
        }

        #region App Event Handlers
        /// <summary>
        /// Evènement lancé lorsque l'application se termine.
        /// </summary>
        /// <param name="sender">object</param>
        /// <param name="e">EventArgs</param>
        private void CurrentDomain_ProcessExit(object sender, EventArgs e)
        {
           
        }
        /// <summary>
        /// Evènement lancé lorsqu'une exception n'a pas été traité autre part dans le thread du Dispatcher.
        /// </summary>
        /// <param name="sender">object</param>
        /// <param name="e">DispatcherUnhandledExceptionEventArgs</param>
        private void Current_DispatcherUnhandledException(object sender, DispatcherUnhandledExceptionEventArgs e)
        {
            HandleException(e.Exception as Exception);
            e.Handled = true;
        }
        /// <summary>
        /// Evènement lancé lorsqu'une exception n'a pas été traité autre part dans le domaine courant.
        /// </summary>
        /// <param name="sender">object</param>
        /// <param name="e">UnhandledExceptionEventArgs</param>
        private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
        {
            HandleException(e.ExceptionObject as Exception);
        }
        /// <summary>
        /// Evènement lancé lorsqu'une exception n'a pas été traité autre part dans l'application.
        /// </summary>
        /// <param name="sender">object</param>
        /// <param name="e">UnhandledExceptionEventArgs</param>
        private static void AppDomainUnhandledException(object sender, UnhandledExceptionEventArgs e)
        {
            HandleException(e.ExceptionObject as Exception);
        }
        /// <summary>
        /// Traitement de la dernière chance pour les exceptions non traitées.
        /// </summary>
        /// <param name="ex"></param>
        private static void HandleException(Exception ex)
        {
            try
            {
                if (ex == null)
                    return;

                MessageBox.Show("L'application a rencontré une erreur inattendue.", "Erreur", MessageBoxButton.OK, MessageBoxImage.Error, MessageBoxResult.OK);

                // Cas où la fenêtre principale n'est pas ouverte, fermer le processus
                // (Sinon, il continue de tourner en background)
                if (!(App.Current != null && App.Current.MainWindow != null && App.Current.MainWindow.IsHitTestVisible))
                    App.Current.Shutdown(1);
            }
            catch
            {
                // Cas où l'erreur n'a pas du tout était catchée.
                MessageBox.Show("Erreur globale", "Erreur", MessageBoxButton.OK, MessageBoxImage.Exclamation, MessageBoxResult.OK);
                if (App.Current != null)
                    App.Current.Shutdown(1);
                else
                    Environment.Exit(1);
            }
        }
        #endregion
    }
}
